{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "7421cef5",
   "metadata": {},
   "source": [
    "### 初始化环境"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "18cdf54d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 在jupyter notebook里env.render看不到窗口\n",
    "# 写一个helper类，用matplotlib刷新显示图像\n",
    "# 初始化传入env，调用helper的render即可\n",
    "from IPython import display # 导入display模块，用于在Jupyter Notebook中显示图像\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt # 导入matplotlib库，用于绘制图像\n",
    "%matplotlib inline\n",
    "\n",
    "class GymHelper:\n",
    "    def __init__(self, env, figsize = (3, 3)):\n",
    "        self.env = env # 初始化Gym环境\n",
    "        self.figsize = figsize # 初始化绘图窗口大小\n",
    "        \n",
    "        plt.figure(figsize = figsize) # 创建绘图窗口\n",
    "        plt.title(self.env.spec.id) # 标题设为环境名\n",
    "        self.img = plt.imshow(env.render()) # 在绘图窗口中显示初始图像\n",
    "    \n",
    "    def render(self, title = None):\n",
    "        image_data = self.env.render() # 获取当前环境图像渲染数据\n",
    "        \n",
    "        self.img.set_data(image_data) # 更新绘图窗口中的图像数据\n",
    "        display.display(plt.gcf()) # 刷新显示\n",
    "        display.clear_output(wait = True) # 有新图片时再清除绘图窗口原有图像\n",
    "        if title: # 如果有标题，就显示标题\n",
    "            plt.title(title)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "5881877f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 216x216 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 导入gym库\n",
    "import gym\n",
    "\n",
    "# 创建CartPole环境，指定渲染模式为rgb_array，如果是在IDE中可以改为'human'\n",
    "env = gym.make('CartPole-v1', render_mode='rgb_array')\n",
    "# 重置环境\n",
    "env.reset()\n",
    "# 创建GymHelper\n",
    "gym_helper = GymHelper(env)\n",
    "\n",
    "# 循环N次\n",
    "for i in range(100):\n",
    "    gym_helper.render(title = str(i)) # 渲染环境\n",
    "    action = env.action_space.sample() # 从动作空间中随机选取一个动作\n",
    "    observation, reward, terminated, truncated, info = env.step(action) # 执行动作\n",
    "    if terminated or truncated: # 如果游戏结束，则结束循环\n",
    "        break\n",
    "\n",
    "# 游戏结束\n",
    "gym_helper.render(title = \"Finished\")\n",
    "# 关闭环境\n",
    "env.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1a86c4be",
   "metadata": {},
   "source": [
    "环境介绍 https://www.gymlibrary.dev/environments/classic_control/cart_pole/"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "294a8fd4",
   "metadata": {},
   "source": [
    "### DQN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "ce08e15f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 导入必要的库\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "import torch.nn.functional as F\n",
    "\n",
    "import numpy as np\n",
    "import sys\n",
    "import time\n",
    "import random\n",
    "import collections\n",
    "from tqdm import * # 用于显示进度条\n",
    "\n",
    "# 定义简单神经网络\n",
    "class Net(nn.Module):\n",
    "    def __init__(self, input_dim, output_dim):\n",
    "        super(Net, self).__init__()\n",
    "        self.input_dim = input_dim # 网络的输入维度\n",
    "        self.output_dim = output_dim # 网络的输出维度\n",
    "        \n",
    "        # 定义一个仅包含全连接层的网络，激活函数使用ReLU函数\n",
    "        self.fc = nn.Sequential(\n",
    "            nn.Linear(self.input_dim, 64),\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(64, 128),\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(128, self.output_dim)\n",
    "        )\n",
    "    \n",
    "    # 定义前向传播，输出动作Q值\n",
    "    def forward(self, state):\n",
    "        action = self.fc(state)\n",
    "        return action"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "f7ebfe82",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 经验回放缓冲区\n",
    "class ReplayBuffer:\n",
    "    # 构造函数，max_size是缓冲区的最大容量\n",
    "    def __init__(self, max_size):\n",
    "        self.max_size = max_size\n",
    "        self.buffer = collections.deque(maxlen = self.max_size)  # 用collections的队列存储，先进先出\n",
    "\n",
    "    # 添加experience（五元组）到缓冲区\n",
    "    def add(self, state, action, reward, next_state, done):\n",
    "        experience = (state, action, reward, next_state, done)\n",
    "        self.buffer.append(experience)\n",
    "\n",
    "    # 从buffer中随机采样，数量为batch_size\n",
    "    def sample(self, batch_size):\n",
    "        batch = random.sample(self.buffer, batch_size)\n",
    "        state, action, reward, next_state, done = zip(*batch)\n",
    "        return state, action, reward, next_state, done\n",
    "    \n",
    "    # 返回缓冲区数据数量\n",
    "    def __len__(self):\n",
    "        return len(self.buffer)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "23fb1098",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 定义DQN类\n",
    "class DQN:\n",
    "    # 构造函数，参数包含环境，学习率，折扣因子，经验回放缓冲区大小，目标网络更新频率\n",
    "    def __init__(self, env, learning_rate=0.001, gamma=0.99, buffer_size=10000, T=10):\n",
    "        self.env = env\n",
    "        self.learning_rate = learning_rate\n",
    "        self.gamma = gamma\n",
    "        self.replay_buffer = ReplayBuffer(max_size=buffer_size)\n",
    "        self.T = T\n",
    "\n",
    "        # 判断可用的设备是 CPU 还是 GPU\n",
    "        self.device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "\n",
    "        # 定义Q网络和目标网络，模型结构是一样的\n",
    "        self.model = Net(env.observation_space.shape[0], env.action_space.n).to(self.device)\n",
    "        self.target_model = Net(env.observation_space.shape[0], env.action_space.n).to(self.device)\n",
    "\n",
    "        # 初始化时，令目标网络的参数就等于Q网络的参数\n",
    "        for param, target_param in zip(self.model.parameters(), self.target_model.parameters()):\n",
    "            target_param.data.copy_(param)\n",
    "\n",
    "        # 定义Adam优化器\n",
    "        self.optimizer = torch.optim.Adam(self.model.parameters(), lr=learning_rate)\n",
    "        \n",
    "        # 记录模型更新的次数，用于决定何时更新目标模型\n",
    "        self.update_count = 0\n",
    "    \n",
    "    # 根据epsilon-greedy策略选择动作\n",
    "    def choose_action(self, state, epsilon=0.1):\n",
    "        if np.random.rand() < epsilon: # 以epsilon的概率随机选择一个动作\n",
    "            return np.random.randint(self.env.action_space.n)\n",
    "        else: # 否则选择模型认为最优的动作\n",
    "            state = torch.FloatTensor(np.array([state])).to(self.device)\n",
    "            action = self.model(state).argmax().item()\n",
    "            return action\n",
    "    \n",
    "    # 计算损失函数，参数batch为随机采样的一批数据\n",
    "    def compute_loss(self, batch):\n",
    "        # 取出数据，并将其转换为numpy数组\n",
    "        # 然后进一步转换为tensor，并将数据转移到指定计算资源设备上\n",
    "        states, actions, rewards, next_states, dones = batch\n",
    "        states = torch.FloatTensor(np.array(states)).to(self.device)\n",
    "        actions = torch.tensor(np.array(actions)).view(-1, 1).to(self.device)\n",
    "        rewards = torch.FloatTensor(np.array(rewards)).view(-1, 1).to(self.device)\n",
    "        next_states = torch.FloatTensor(np.array(next_states)).to(self.device)\n",
    "        dones = torch.FloatTensor(np.array(dones)).view(-1, 1).to(self.device)\n",
    "\n",
    "        # 计算当前Q值，即Q网络对当前状态动作样本对的Q值估计\n",
    "        curr_Q = self.model(states).gather(1, actions)\n",
    "        # 计算目标网络对下一状态的Q值估计\n",
    "        next_Q = self.target_model(next_states)\n",
    "        # 选择下一状态中最大的Q值\n",
    "        max_next_Q = torch.max(next_Q, 1)[0].view(-1, 1)\n",
    "        # 计算期望的Q值，若达到终止状态则直接是reward\n",
    "        expected_Q = rewards + (1 - dones) * self.gamma * max_next_Q\n",
    "        \n",
    "        # 计算当前Q值和期望Q值之间的均方误差，返回结果\n",
    "        loss = torch.mean(F.mse_loss(curr_Q, expected_Q))\n",
    "        return loss\n",
    "    \n",
    "    # 模型更新，参数为批次大小\n",
    "    def update(self, batch_size):\n",
    "        # 从经验回放缓冲区中随机采样\n",
    "        batch = self.replay_buffer.sample(batch_size)\n",
    "        # 计算这部分数据的损失\n",
    "        loss = self.compute_loss(batch)\n",
    "\n",
    "        # 梯度清零、反向传播、更新参数\n",
    "        self.optimizer.zero_grad()\n",
    "        loss.backward()\n",
    "        self.optimizer.step()\n",
    "        \n",
    "        # 每隔一段时间，更新目标网络的参数\n",
    "        if self.update_count % self.T == 0:\n",
    "            for param, target_param in zip(self.model.parameters(), self.target_model.parameters()):\n",
    "                target_param.data.copy_(param)\n",
    "        # 记录模型更新的次数\n",
    "        self.update_count += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "66c03c71",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Episode 0: 11.0                        \n",
      "Episode 40: 97.0                                \n",
      "Episode 80: 268.0                               \n",
      "Episode 120: 484.0                               \n",
      "Episode 160: 432.0                               \n",
      "100%|██████████| 200/200 [01:54<00:00,  1.74it/s]\n"
     ]
    }
   ],
   "source": [
    "# 定义超参数\n",
    "max_episodes = 200 # 训练episode数\n",
    "max_steps = 500 # 每个回合的最大步数\n",
    "batch_size = 32 # 采样数\n",
    "\n",
    "# 创建DQN对象\n",
    "agent = DQN(env)\n",
    "# 定义保存每个回合奖励的列表\n",
    "episode_rewards = []\n",
    "\n",
    "# 开始循环，tqdm用于显示进度条并评估任务时间开销\n",
    "for episode in tqdm(range(max_episodes), file=sys.stdout):\n",
    "    # 重置环境并获取初始状态\n",
    "    state, _ = env.reset()\n",
    "    # 当前回合的奖励\n",
    "    episode_reward = 0\n",
    "\n",
    "    # 循环进行每一步操作\n",
    "    for step in range(max_steps):\n",
    "        # 根据当前状态选择动作\n",
    "        action = agent.choose_action(state)\n",
    "        # 执行动作，获取新的信息\n",
    "        next_state, reward, terminated, truncated, info = env.step(action)\n",
    "        # 判断是否达到终止状态\n",
    "        done = terminated or truncated\n",
    "        \n",
    "        # 将这个五元组加到缓冲区中\n",
    "        agent.replay_buffer.add(state, action, reward, next_state, done)\n",
    "        # 累计奖励\n",
    "        episode_reward += reward\n",
    "\n",
    "        # 如果经验回放缓冲区已经有足够数据，就更新网络参数\n",
    "        if len(agent.replay_buffer) > batch_size:\n",
    "            agent.update(batch_size)\n",
    "        \n",
    "        # 更新当前状态\n",
    "        state = next_state\n",
    "\n",
    "        if done:\n",
    "            break\n",
    "    # 记录当前回合奖励值\n",
    "    episode_rewards.append(episode_reward)\n",
    "    # 打印中间值\n",
    "    if episode % 40 == 0:\n",
    "        tqdm.write(\"Episode \" + str(episode) + \": \" + str(episode_reward))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "442cc706",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 使用Matplotlib绘制奖励值的曲线图\n",
    "plt.plot(episode_rewards)\n",
    "plt.title(\"reward\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "f5ab5837",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 216x216 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 重置环境，开始新的一轮游戏\n",
    "observation, _ = env.reset()\n",
    "# 创建GymHelper对象来辅助显示\n",
    "gym_helper = GymHelper(env, figsize = (3, 3))\n",
    "\n",
    "# 开始游戏\n",
    "for i in range(500):\n",
    "    # 渲染环境，title为当前步骤数\n",
    "    gym_helper.render(title = str(i))\n",
    "    \n",
    "    # 通过Q网络找到当前状态下的最优动作\n",
    "    action = agent.choose_action(observation, 0)\n",
    "    # 执行action，获取新的信息\n",
    "    observation, reward, terminated, truncated, info = env.step(action)\n",
    "    \n",
    "    # 如果游戏结束，则结束当前循环\n",
    "    if terminated or truncated:\n",
    "        break\n",
    "\n",
    "# 游戏结束\n",
    "gym_helper.render(title = \"Finished\")\n",
    "# 关闭环境\n",
    "env.close()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
